# -*- coding: utf-8 -*-
import randomfrom legendaryPowerClientScript.util import apiUtil, vectorfrom legendaryPowerClientScript.util.vector import Vectorimport mod.client.extraClientApi as clientApidef factoryCuboid(center, horizontalRadius, verticalRadius, down=True):
    # type: (Vector, float, float) -> CuboidBoundingBox
    """
    创建一个立方体碰撞箱

    Args:
        center (Vector): 立方体的中心点坐标
        horizontalRadius (float): 立方体的水平半径
        verticalRadius (float): 立方体的垂直半径
        down (bool, optional): 是否向下延伸，默认为True

    Returns:
        CuboidBoundingBox: 创建的立方体碰撞箱对象
    """
    pass

def findBlockHit(start, end, minY=None, step=0.1):
    # type: (Vector, Vector, float or None, optional, float or None, optional) -> Vector or None
    """
    查找射线与方块的碰撞点

    Args:
        start (Vector): 射线起始点坐标
        end (Vector): 射线终点坐标
        step (float or None, optional): 射线前进的步长，默认为0.1
        minY (float or None, optional): Y坐标的最小值，默认为None

    Returns:
        Vector or None: 碰撞点坐标，若无碰撞则返回None
    """
    pass

def findHitEntities(start, end, checkCanHit=None):
    # type: (Vector, Vector) -> list[tuple[Creature, Vector, float]]
    """
    查找射线与实体的碰撞点

    Args:
        start (Vector): 射线起始点坐标
        end (Vector): 射线终点坐标
        expand (bool, optional): 是否扩展实体碰撞箱，默认为False

    Returns:
        list[tuple[Creature, Vector, float]]: 碰撞的实体列表，每个元素为(Creature, 碰撞点坐标, 到射线起始点的距离平方)的元组
    """
    pass

class SphereBoundingBox:
    """
    表示一个球形边界框的类。
    """

    def __init__(self, center, radius):
        """
        表示一个球形边界框的类。
        Attributes:
            center (Vector): 球体的中心点坐标。
            radius (float): 球体的半径。
        """
        self.center = Vector()  # type: Vector
        self.radius = 0.0  # type: float
        pass

    def intersects(self, other):
        # type: (Vector or ClientCreature) -> bool
        """
        检查一个对象是否在球体内。

        Args:
            item (Vector or ClientCreature): 需要检查的对象。

        Returns:
            bool: 如果对象在球体内则返回True，否则返回False。
        """
        pass

    def getCenter(self):
        # type: () -> Vector
        """
        获取球体的中心点坐标。

        Returns:
            Vector: 球体的中心点坐标。
        """
        pass

    def getRadius(self):
        # type: () -> float
        """
        获取球体的半径。

        Returns:
            float: 球体的半径。
        """
        pass

    def findEntitiesInside(self):
        # type: () -> list[str]
        """
        查找球体内的实体。

        Returns:
            list[Creature]: 球体内的实体对象列表。
        """
        pass

class CuboidBoundingBox:
    """
    表示一个长方体碰撞箱的类。注意，此碰撞箱和原版的相同，即：不能旋转，三个轴永远与x,y,z轴平行。若需要可旋转的碰撞箱，请用OBB类
    """

    def __init__(self, minV, maxV):
        # type: (Vector, Vector) -> CuboidBoundingBox
        """
        新建一个长方体碰撞箱的类。

        Attributes:
            min (Vector): 碰撞箱的最小点坐标。
            max (Vector): 碰撞箱的最大点坐标。
        """
        pass

    def midPoint(self):
        # type: () -> Vector
        """
        计算碰撞箱的中心点。
        Returns:
            Vector: 碰撞箱的中心点坐标。
        """
        pass

    def offset(self, vec):
        # type: () -> CuboidBoundingBox
        """
        将整个碰撞箱向指定方向偏移

        Returns:
            CuboidBoundingBox: 偏移后的碰撞箱
        """
        pass

    def intersects(self, other):
        # type: (Vector 或 CuboidBoundingBox or ClientCreature) -> bool
        """
        判断碰撞箱是否与另一个对象相交。

        Args:
            other (Vector 或 CuboidBoundingBox or ClientCreature): 要判断的对象。

        Returns:
            bool: 如果碰撞箱与对象相交，则为True；否则为False。
        """
        pass

    def __contains__(self, item):
        """
        判断碰撞箱是否包含指定的对象。

        Args:
            item (Vector 或 CuboidBoundingBox): 要判断的对象。

        Returns:
            bool: 如果碰撞箱包含指定的对象，则为True；否则为False。
        """
        pass

    def expand(self, x, y, z):
        # type: (float, float, float) -> CuboidBoundingBox
        """
        将碰撞箱扩展一定的大小。

        Args:
            x (float): x方向的扩展量。
            y (float): y方向的扩展量。
            z (float): z方向的扩展量。

        Returns:
            CuboidBoundingBox: 扩展后的碰撞箱。

        """
        pass

    def randomPoint(self):
        # type: () -> Vector
        """
        在碰撞箱内随机生成一个点。

        Returns:
            Vector: 生成的随机点的坐标。

        """
        pass

    def calculateIntercept(self, p1, p2):
        # type: (Vector, Vector) -> Vector
        """
        计算从A发射到B的射线与碰撞箱的碰撞点

        Args:
            p1 (Vector): 发射点A
            p2 (Vector): 目标点B

        Returns:
            Vector: 碰撞点，若没碰撞则返回None
        """
        pass

    def findEntitiesInside(self, excludeSelf=False):
        # type: () -> list[str]
        """
        查找在边界框内的实体列表

        Returns:
            list[Creature]: 实体列表
        """
        pass

    def findSafeSpawnLocation(self):
        # type: () -> Vector
        """
        在区域中寻找安全的生成点位置
        Returns:
            Vector: 安全的生成点位置
        """
        pass

    def toFloatTuple(self):
        # type: () -> tuple
        """
        将边界框的坐标转换为浮点元组

        Returns:
            tuple: 浮点元组
        """
        pass

